jvn.JvnWrapperCreator Class Reference

List of all members.

Static Public Member Functions
static void	main (String[] args)
Protected Member Functions
synchronized Class<?>	loadClass (final String name, final boolean resolve) throws ClassNotFoundException
Static Private Member Functions
static void	execute (String[] args)
static void	generateOneFile (String wholeClassName, Vector< Method > readMethods, Vector< Method > writeMethods, Vector< Method > normalMethods, Constructor[] constructors)
Static Private Attributes
static Pattern	pattern = Pattern.compile("^([A-Za-z][A-Za-z0-9.]*)+$")
static Matcher	matcher

---

Detailed Description

Significant blocks of code found in: * the ASM "Adapt" example; * The Java Developers Almanac;

Author:

Lionel DEBROUX, http://lionel.debroux.free.fr

Savas Ali TOKMEN, http://ali.tokmen.com

Definition at line 36 of file JvnWrapperCreator.java.

---

Member Function Documentation

static void jvn.JvnWrapperCreator.main

(

String[]

args

)

[static]

Variables used to save information about the current class. Just because making a large main is supposed to be bad C-like Java :P

Parameters:

args

Program arguments.

Definition at line 57 of file JvnWrapperCreator.java.

References jvn.JvnWrapperCreator.execute().

                                               {
                execute(args);
        }

Here is the call graph for this function:

static void jvn.JvnWrapperCreator.execute

(

String[]

args

)

[static, private]

Core of the program

Parameters:

args

Program arguments, as if they were entered on the command line.

Definition at line 65 of file JvnWrapperCreator.java.

References jvn.JvnWrapperCreator.generateOneFile(), jvn.JvnWrapperCreator.loadClass(), jvn.JvnWrapperCreator.matcher, and jvn.JvnWrapperCreator.pattern.

Referenced by jvn.JvnWrapperCreator.main().

                                                    {
                String className;
                Vector<Method> writeMethods;
                Vector<Method> readMethods;             
                Vector<Method> normalMethods;
                JvnWrapperCreator creator;
                
                
                creator = new JvnWrapperCreator();
                writeMethods = new Vector<Method>();
                readMethods = new Vector<Method>();
                normalMethods = new Vector<Method>();

                System.out.println("Usage: JvnWrapperCreator <complete class names (without \".class\")>");
                //System.out.println("For now, classes are not supposed to have a constructor of the following form:");
                //System.out.println("public Foo(java.lang.Serializable o);");
                //System.out.println("Read the source for more details.");

                if (args.length != 0) {
                        String name;
                        for (String s : args) {
                                // Stupid bug, simple fix: don't forget to clear our
                                // internal structures for each file !
                                writeMethods.clear();
                                readMethods.clear();
                                normalMethods.clear();
                                
                                matcher = pattern.matcher(s);
                                if (matcher.matches()) {
                                        // Classes are supposed to be under the "build" folder.
                                        //currentFilename = s.replace('.', '/') + ".class";
                                        //currentFile = new File("build/" + currentFilename);
                                        name = s;
                                        //System.out.println(name);
                                        Logger.global.info("Treating class \"" + name +"\"");
                                        try {
                                                JvnWrite w;
                                                JvnRead r;

                                                //System.out.println(name);

                                                Class c = creator.loadClass(name,true);

                                                if (c != null) {

                                                        Method [] methods = c.getDeclaredMethods();
                                                        Constructor [] constructors = c.getConstructors();

                                                        //System.out.println("Methods in \"" + name + "\":");
                                                        for (Method m : methods) {
                                                                //System.out.print(m.toGenericString());
                                                                
                                                                // Don't generate wrappers for PROTECTED or PRIVATE methods !
                                                                if ((m.getModifiers() & (Modifier.PROTECTED | Modifier.PRIVATE)) != 0) {
                                                                        continue;
                                                                }

                                                                w = m.getAnnotation(JvnWrite.class);
                                                                r = m.getAnnotation(JvnRead.class);

                                                                // Do something if
                                                                // annotation @JvnWrite is present
                                                                // XOR
                                                                // annotation @JvnRead is present
                                                                // (AND makes no sense).
                                                                if ((w != null) ^ (r != null)) {
                                                                        if (w != null) {
                                                                                // Add method to list of @JvnWrite methods.
                                                                                Logger.global.info("@JvnWrite on method \"" + m.toGenericString() + "\".");
                                                                                
                                                                                writeMethods.add(m);
                                                                        }
                                                                        else {
                                                                                // Add method to list of @JvnRead methods.
                                                                                Logger.global.info("@JvnRead on method \"" + m.toGenericString() + "\".");

                                                                                readMethods.add(m);
                                                                        }
                                                                }
                                                                else if ((w != null) && (r != null)) {
                                                                        System.err.println("Having both @JvnWrite and @JvnRead on a method does not make any sense !");
                                                                }
                                                                else {
                                                                        normalMethods.add(m);
                                                                }

                                                                System.out.println("");

                                                        }
                                                        
                                                        className = name;
                                                        
                                                        generateOneFile(className, readMethods, writeMethods, normalMethods, constructors);
                                                }
                                                else {
                                                        System.err.println("Error: couldn't load class \"");
                                                }

                                        } catch (ClassNotFoundException e) {
                                                System.err.println("Error: class \"" + s + "\" not found !");
                                                e.printStackTrace();
                                        }

                                }
                                else {
                                        System.err.println("Error: invalid filename \"" + s + "\" !");
                                }
                        }

                }
                else {

                }

        }

Here is the call graph for this function:

Here is the caller graph for this function:

static void jvn.JvnWrapperCreator.generateOneFile	(	String	wholeClassName,
		Vector< Method >	readMethods,
		Vector< Method >	writeMethods,
		Vector< Method >	normalMethods,
		Constructor[]	constructors
	)			[static, private]

Generate code for a single file.

We generate as much as possible on the Java side, before putting in the context, because it's easier and more flexible. However, it also makes Velocity even less useful...

Definition at line 188 of file JvnWrapperCreator.java.

References jvn.Signature.setValues().

Referenced by jvn.JvnWrapperCreator.execute().

                                                                                                                                                                                      {
                String packageName;
                String className;
                String [] strings;
                
                Vector<Signature> signatures = new Vector<Signature>();
                
                for (Constructor c : constructors) {
                        Signature s = new Signature();
                        s.setValues(c);
                        signatures.add(s);
                }

                for (Method m : readMethods) {
                        Signature s = new Signature();
                        s.setValues(m);
                        signatures.add(s);
                }

                for (Method m : writeMethods) {
                        Signature s = new Signature();
                        s.setValues(m);
                        signatures.add(s);
                }
                
                for (Method m : normalMethods) {
                        Signature s = new Signature();
                        s.setValues(m);
                        signatures.add(s);
                }

                
                strings = wholeClassName.split("\\.");

                // Class name is the last part of the whole class name.
                if (strings.length > 1) {
                        packageName = new String(strings[0]);
                }
                else {
                        packageName = null;
                        if (strings.length != 1) {
                                // Not supposed to occur !
                                System.err.println("Incorrect class name !");
                                return; // THIS returns !
                        }
                }
                className = strings[strings.length - 1];

                // Package name is the rest of the whole class name.
                // (Hey, no string "join" operation in Java ?)
                if (packageName != null) {
                        // If there's a package name (i.e. if strings.length > 1)
                        for (int i = 1; i < strings.length - 1; i++) {
                                packageName = packageName + "." + strings[i];
                        }
                }
                
                
                
                // get & initialize the velocity engine
                VelocityEngine ve = new VelocityEngine();
                
                try {
                        ve.init();
                        
                        // get the template
                        Template t = ve.getTemplate("jvnwrappercreator.vm");
                        // create a context & add data
                        VelocityContext context = new VelocityContext();
                        context.put("className", className);
                        context.put("packageName", packageName);
                        context.put("constructorsAndMethods",signatures);
                        
                        /*for (Constructor c : constructors) {
                                System.out.println(c.toGenericString());
                                modifiers.add(Modifier.toString(c.getModifiers()));
                        }*/
                        
                        //System.out.println(className);
                        //System.out.println(packageName);
                        
                        // perform generation
                        //StringWriter writer = new StringWriter();
                        if (packageName == null) {
                                packageName = "";
                        }
                        File file = new File("src/" + packageName.replace('.', '/') + "/Jvn" + className + ".java");
                        FileWriter writer = new FileWriter(file);
                        t.merge(context, writer);
                        writer.flush();
                        //System.out.println(writer.toString());
                }
                catch (Exception e) {
                        e.printStackTrace(System.err);
                }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

synchronized Class<?> jvn.JvnWrapperCreator.loadClass	(	final String	name,
		final boolean	resolve
	)			throws ClassNotFoundException [protected]

Definition at line 285 of file JvnWrapperCreator.java.

Referenced by jvn.JvnWrapperCreator.execute().

                                                                                                                         {
                //FileInputStream fis;

        return super.loadClass(name, resolve);
        }

Here is the caller graph for this function:

---

Member Data Documentation

Pattern jvn.JvnWrapperCreator.pattern = Pattern.compile("^([A-Za-z][A-Za-z0-9.]*)+$") [static, private]

Pattern & matcher used to check the validity of class names.

Definition at line 45 of file JvnWrapperCreator.java.

Referenced by jvn.JvnWrapperCreator.execute().

Matcher jvn.JvnWrapperCreator.matcher [static, private]

Definition at line 46 of file JvnWrapperCreator.java.

Referenced by jvn.JvnWrapperCreator.execute().

---

The documentation for this class was generated from the following file:

• JvnWrapperCreator.java

---